An “application” is a computer program that provides a group of coordinated functions, tasks or activities to users. The performance of applications has been improved while the associated development costs have been reduced by utilizing object-oriented computing techniques. Object-oriented computing techniques differ from traditional function-oriented techniques in that small, reusable sections of program code known as “objects” can be quickly and easily combined and re-used to create new programs. The modular and re-usable aspects of objects can speed development of new programs, thereby reducing the costs associated with the development cycle. In addition, by creating and re-using a comprehensive set of well-tested objects, a more stable, uniform, and consistent approach to developing new computer programs can be achieved.
Many object-oriented computer systems support multiple concurrent execution threads each of which can independently search for and attempt to access objects in an object pool library. Two different threads, however, may attempt to access the same object simultaneously, resulting in “contention.” To arbitrate between the different threads, conventional computer systems implement mutual-exclusion (“mutex”) primitives to ensure that one object cannot be allocated to two different threads simultaneously. Typically, mutual-exclusion primitives rely on a locking scheme—when one thread is accessing the object, other threads are “locked” out; only when the one thread finishes its current execution is the object released and made accessible to other threads.
Searching a desired object in an object pool library, however, is already time-consuming and the delays associated with contention resolution slow performance still further. The more threads that concurrently execute, the greater will be the problem, particularly where large numbers of execution threads attempt to access the same object sequentially and/or simultaneously in an unorganized fashion. Accordingly, there is a need for an approach that allows multiple threads to access objects in an organized fashion without the need for searching and locking of objects.